package com.wormhole.wormholemanagement.utils;

import java.io.*;
import java.util.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class ZipExporter {
    // 媒体文件扩展名集合
    private static final Set<String> AUDIO_EXTENSIONS = new HashSet<>(Arrays.asList(
            "mp3", "wav", "flac", "aac", "ogg", "wma", "m4a"
    ));

    private static final Set<String> VIDEO_EXTENSIONS = new HashSet<>(Arrays.asList(
            "mp4", "avi", "mov", "mkv", "flv", "wmv", "mpeg", "mpg"
    ));

    private static final Set<String> IMAGE_EXTENSIONS = new HashSet<>(Arrays.asList(
            "jpg", "jpeg", "png", "gif", "bmp", "tiff", "webp", "heic", "raw"
    ));

    /**
     * 打包相片档案目录（支持文件路径字符串）
     * @param unitName 单位名称
     * @param baseDir 基础目录（如"D:\\相片档案"）
     * @param baseYear 基准年份目录（如"2025"）
     * @param moveFilePaths 移馆文件路径列表（字符串）
     * @param noMoveFilePaths 不移馆文件路径列表（字符串）
     * @param zipFilePath 目标ZIP文件路径
     * @return 打包是否成功
     */
    public static boolean zipPhotoArchivesStr(String unitName, String baseDir, String baseYear,
                                           List<String> moveFilePaths, List<String> noMoveFilePaths, String zipFilePath) {
        // 将路径字符串转换为File对象
        List<File> moveFiles = convertPathsToFiles(moveFilePaths);
        List<File> noMoveFiles = convertPathsToFiles(noMoveFilePaths);

        // 调用原有逻辑处理
        return zipPhotoArchives(unitName, baseDir, baseYear, moveFiles, noMoveFiles, zipFilePath);
    }

    /**
     * 核心打包方法（File对象版本）
     */
    public static boolean zipPhotoArchives(String unitName, String baseDir, String baseYear,
                                           List<File> moveFiles, List<File> noMoveFiles, String zipFilePath) {
        // 标准化基础目录路径（处理斜杠和反斜杠）
        baseDir = baseDir.replace("/", File.separator);
        if (!baseDir.endsWith(File.separator)) {
            baseDir += File.separator;
        }

        // 创建ZIP文件父目录
        File zipFile = new File(zipFilePath);
        File parentDir = zipFile.getParentFile();
        if (parentDir != null && !parentDir.exists() && !parentDir.mkdirs()) {
            System.err.println("无法创建ZIP文件的父目录: " + parentDir.getAbsolutePath());
            return false;
        }

        try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipFilePath))) {
            // 处理移馆文件
            processFileList(moveFiles, unitName, "移馆", baseDir, baseYear, zos);

            // 处理不移馆文件
            processFileList(noMoveFiles, unitName, "不移馆", baseDir, baseYear, zos);

            System.out.println("ZIP文件创建成功: " + zipFilePath);
            return true;
        } catch (IOException e) {
            System.err.println("创建ZIP文件失败: " + e.getMessage());
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将文件路径字符串列表转换为File对象列表
     */
    private static List<File> convertPathsToFiles(List<String> filePaths) {
        List<File> files = new ArrayList<>();
        if (filePaths == null || filePaths.isEmpty()) {
            return files;
        }

        for (String path : filePaths) {
            if (path != null && !path.trim().isEmpty()) {
                File file = new File(path.trim());
                if (file.exists() && file.isFile()) {
                    files.add(file);
                } else {
                    System.err.println("无效的文件路径或文件不存在: " + path);
                }
            }
        }
        return files;
    }

    /**
     * 处理文件列表，构建指定的目录结构
     */
    private static void processFileList(List<File> files, String unitName, String moveStatus,
                                        String baseDir, String baseYear, ZipOutputStream zos) throws IOException {
        if (files == null || files.isEmpty()) {
            System.out.println("没有" + moveStatus + "文件需要处理");
            return;
        }

        for (File file : files) {
            if (file.isFile()) {
                // 确定文件类型目录
                String fileTypeDir = getFileTypeDirectory(file.getName());
                if (fileTypeDir == null) {
                    System.out.println("跳过不支持的文件类型: " + file.getName());
                    continue;
                }

                // 获取文件相对基础目录的路径
                String filePath = file.getAbsolutePath();
                if (!filePath.startsWith(baseDir)) {
                    System.out.println("文件不在基础目录下，跳过: " + filePath);
                    continue;
                }

                // 提取基础目录之后的路径部分（保留完整结构）
                String relativeToBase = filePath.substring(baseDir.length());

                // 验证路径包含年份目录
                if (!relativeToBase.startsWith(baseYear + File.separator)) {
                    System.out.println("文件不在" + baseYear + "目录下，跳过: " + filePath);
                    continue;
                }

                // 构建完整的ZIP内部路径
                String zipEntryPath = String.join("/",
                        unitName,
                        moveStatus,
                        fileTypeDir,
                        relativeToBase
                );
                // 统一路径分隔符为ZIP标准的正斜杠
                zipEntryPath = zipEntryPath.replace(File.separator, "/");

                // 添加到ZIP
                ZipEntry zipEntry = new ZipEntry(zipEntryPath);
                zos.putNextEntry(zipEntry);

                try (InputStream is = new FileInputStream(file)) {
                    byte[] buffer = new byte[4096];
                    int bytesRead;
                    while ((bytesRead = is.read(buffer)) != -1) {
                        zos.write(buffer, 0, bytesRead);
                    }
                }
                zos.closeEntry();
                System.out.println("已添加: " + zipEntryPath);
            }
        }
    }

    /**
     * 根据文件名判断文件类型目录
     */
    private static String getFileTypeDirectory(String fileName) {
        int dotIndex = fileName.lastIndexOf('.');
        if (dotIndex == -1 || dotIndex == fileName.length() - 1) {
            return null; // 无扩展名
        }

        String extension = fileName.substring(dotIndex + 1).toLowerCase();

        if (AUDIO_EXTENSIONS.contains(extension)) {
            return "音频";
        } else if (VIDEO_EXTENSIONS.contains(extension)) {
            return "视频";
        } else if (IMAGE_EXTENSIONS.contains(extension)) {
            return "照片";
        } else {
            return null; // 不支持的类型
        }
    }

    /**
     * 从目录加载所有文件路径（辅助方法）
     */
    private static List<String> loadAllFilePaths(File dir) {
        List<String> filePaths = new ArrayList<>();
        if (dir.exists() && dir.isDirectory()) {
            File[] files = dir.listFiles();
            if (files != null) {
                for (File file : files) {
                    if (file.isDirectory()) {
                        filePaths.addAll(loadAllFilePaths(file)); // 递归处理子目录
                    } else {
                        filePaths.add(file.getAbsolutePath()); // 添加文件路径
                    }
                }
            }
        } else {
            System.err.println("目录不存在或不是有效目录: " + dir.getAbsolutePath());
        }
        return filePaths;
    }
}
